home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 8 / QRZ Ham Radio Callsign Database - Volume 8.iso / pc / files / t_unix / j109lxa4.tar / rspfhdr.c < prev    next >
C/C++ Source or Header  |  1994-06-04  |  5KB  |  174 lines
  1. /* Mods by PA0GRI */
  2.  
  3. #include "global.h"
  4. #include "mbuf.h"
  5. #include "internet.h"
  6. #include "ip.h"
  7. #include "timer.h"
  8. #include "rspf.h"
  9.  
  10. /* Convert RRH header in internal format to an mbuf in external format */
  11. struct mbuf *
  12. htonrrh(rrh,data,ph)
  13. struct rrh *rrh;
  14. struct mbuf *data;
  15. struct pseudo_header *ph;
  16. {
  17.     struct mbuf *bp;
  18.     register char *cp, *ck;
  19.     int16 checksum;
  20.  
  21.     /* Allocate RRH header and fill it in */
  22.     bp = pushdown(data,RRHLEN);    /* pushdown never fails */
  23.  
  24.     cp = bp->data;
  25.     *cp++ = rrh->version;        /* Version number */
  26.     *cp++ = RSPF_RRH;        /* Type number */
  27.     ck = cp;
  28.     cp = put16(cp,0);        /* Clear checksum */
  29.     cp = put32(cp,rrh->addr);    /* Source address */
  30.     cp = put16(cp,rrh->seq);    /* Last packet sent sequence number */
  31.     *cp = rrh->flags;        /* Flags */
  32.  
  33.     /* All zeros and all ones is equivalent in one's complement arithmetic;
  34.      * the spec requires us to change zeros into ones to distinguish an
  35.       * all-zero checksum from no checksum at all
  36.      */
  37.     if((checksum = cksum(ph,bp,ph->length)) == 0)
  38.         checksum = 0xffffffff;
  39.     put16(ck,checksum);
  40.     return bp;
  41. }
  42.  
  43. /* Convert RSPF packet header in internal format to an mbuf in external
  44.  * format, without calculating the checksum.
  45.  */
  46. struct mbuf *
  47. htonrspf(pkth,data)
  48. struct rspfpacketh *pkth;
  49. struct mbuf *data;
  50. {
  51.     struct mbuf *bp;
  52.     register unsigned char *cp;
  53.  
  54.     /* Allocate packet header and fill it in */
  55.     bp = pushdown(data,RSPFPKTLEN);    /* pushdown never fails */
  56.  
  57.     cp = (unsigned char *) bp->data;
  58.     *cp++ = (char) pkth->version;    /* Version number */
  59.     *cp++ = (char) pkth->type;    /* Type number */
  60.     *cp++ = pkth->fragn;        /* The fragment number */
  61.     *cp++ = pkth->fragtot;        /* The total number of fragments */
  62.     cp = (unsigned char *) put16((char *)cp,pkth->csum); /* The checksum */
  63.     *cp++ = pkth->sync;        /* The sync octet */
  64.     *cp++ = pkth->nodes;        /* The number of nodes */
  65.     put16((char *)cp,pkth->envid);  /* The envelope-ID */
  66.     return bp;
  67. }
  68.  
  69. /* Convert RSPF header in mbuf to internal structure */
  70. int
  71. ntohrspf(rspf,bpp)
  72. union rspf *rspf;
  73. struct mbuf **bpp;
  74. {
  75.     if(len_p(*bpp) < RSPFPKTLEN) /* Packet too short */
  76.         return -1;
  77.     if((rspf->hdr.version = pullchar(bpp)) != RSPF_VERSION) {
  78.         ++Rspf_stat.badvers;
  79.         return -1;             /* Wrong version */
  80.         }
  81.  
  82.     switch (rspf->hdr.type = pullchar(bpp)){
  83.     case RSPF_RRH:
  84.         if(len_p(*bpp) < RRHLEN - 2)    /* Packet too small */
  85.         return -1;
  86.         rspf->rrh.csum = (int16) pull16(bpp);
  87.         rspf->rrh.addr = pull32(bpp);
  88.         rspf->rrh.seq = (int16) pull16(bpp);
  89.         rspf->rrh.flags = pullchar(bpp);
  90.         break;
  91.     case RSPF_FULLPKT:
  92.         rspf->pkthdr.fragn = pullchar(bpp);
  93.         rspf->pkthdr.fragtot = pullchar(bpp);
  94.         rspf->pkthdr.csum = (int16) pull16(bpp);
  95.         rspf->pkthdr.sync = pullchar(bpp);
  96.         rspf->pkthdr.nodes = pullchar(bpp);
  97.         rspf->pkthdr.envid = (int16) pull16(bpp);
  98.         break;
  99.     default:
  100.         return -1;
  101.     }
  102.     return 0;
  103. }
  104.  
  105. /* Convert RSPF node header in internal format to an mbuf in external format */
  106. struct mbuf *
  107. htonrspfnode(nodeh,data)
  108. struct rspfnodeh *nodeh;
  109. struct mbuf *data;
  110. {
  111.     struct mbuf *bp;
  112.     register char *cp;
  113.  
  114.     /* Allocate node header and fill it in */
  115.     bp = pushdown(data,RSPFNODELEN);    /* pushdown never fails */
  116.  
  117.     cp = bp->data;
  118.     cp = put32(cp,nodeh->addr);        /* Reporting router address */
  119.     cp = put16(cp,(int16)nodeh->seq);    /* Sequence number */
  120.     *cp++ = nodeh->subseq;        /* Sub-sequence number */
  121.     *cp++ = nodeh->links;        /* Number of links */
  122.     return bp;
  123. }
  124.  
  125. /* Convert RSPF node header in mbuf to internal structure */
  126. int
  127. ntohrspfnode(nodeh,bpp)
  128. struct rspfnodeh *nodeh;
  129. struct mbuf **bpp;
  130. {
  131.     if(len_p(*bpp) < RSPFNODELEN) /* Packet too short */
  132.     return -1;
  133.     nodeh->addr = pull32(bpp);
  134.     nodeh->seq = (int16) pull16(bpp);
  135.     nodeh->subseq = (unsigned char) pullchar(bpp);
  136.     nodeh->links = (unsigned char) pullchar(bpp);
  137.     return 0;
  138. }
  139.  
  140. /* Convert RSPF link header in internal format to an mbuf in external format */
  141. struct mbuf *
  142. htonrspflink(linkh,data)
  143. struct rspflinkh *linkh;
  144. struct mbuf *data;
  145. {
  146.     struct mbuf *bp;
  147.     register unsigned char *cp;
  148.  
  149.     /* Allocate link header and fill it in */
  150.     bp = pushdown(data,RSPFLINKLEN);    /* pushdown never fails */
  151.  
  152.     cp = (unsigned char *) bp->data;
  153.     *cp++ = linkh->horizon;        /* Horizon */
  154.     *cp++ = linkh->erp;            /* ERP factor */
  155.     *cp++ = linkh->cost;        /* Link cost */
  156.     *cp++ = linkh->adjn;        /* Number of adjacencies */
  157.     return bp;
  158. }
  159.  
  160. /* Convert RSPF link header in mbuf to internal structure */
  161. int
  162. ntohrspflink(linkh,bpp)
  163. struct rspflinkh *linkh;
  164. struct mbuf **bpp;
  165. {
  166.     if(len_p(*bpp) < RSPFLINKLEN) /* Packet too short */
  167.     return -1;
  168.     linkh->horizon = (unsigned char) pullchar(bpp);
  169.     linkh->erp = (unsigned char) pullchar(bpp);
  170.     linkh->cost = (unsigned char) pullchar(bpp);
  171.     linkh->adjn = (unsigned char) pullchar(bpp);
  172.     return 0;
  173. }
  174.